#include <bits/stdc++.h>
#define int long long
using namespace std;
inline int read()
{
    int ans = 0, f = 0;
    char c = getchar();
    while (!isdigit(c))
        f |= c == '-', c = getchar();
    while (isdigit(c))
        ans = (ans << 3) + (ans << 1) + c - 48, c = getchar();
    return f ? -ans : ans;
}
void write(int x)
{
    if (x < 0)
        putchar('-'), x = -x;
    if (x > 9)
        write(x / 10);
    putchar(48 + x % 10);
}
const int N = 1e5 + 5;
// int n, fl, a[N];
// int num, si[N], vis[N]; // for get_root
// vector<int> g[N];
// struct Path
// {
//     struct BIT
//     {
//         int t[N];
//         inline void add(int k, int v)
//         {
//             while (k <= n)
//                 t[k] += v, k += k & -k;
//         }
//         inline void add(int l, int r, int v) { add(l, v), add(r + 1, -v); }
//         inline int ask(int k)
//         {
//             int ans = 0;
//             while (k)
//                 ans += t[k], k -= k & -k;
//             return ans;
//         }
//     } bit;
//     int cnt, dfn[N], top[N], d[N], fa[N], si[N], son[N];
//     void dfs(int u, int fat)
//     {
//         d[u] = d[fa[u] = fat] + 1, si[u] = 1;
//         for (int v : g[u])
//             if (v != fat)
//             {
//                 dfs(v, u), si[u] += si[v];
//                 if (si[son[u]] < si[v])
//                     son[u] = v;
//             }
//     }
//     void dfs2(int u, int Top)
//     {
//         dfn[u] = ++cnt, top[u] = Top;
//         bit.add(dfn[u], dfn[u], a[u]);
//         if (!son[u])
//             return;
//         dfs2(son[u], Top);
//         for (int v : g[u])
//             if (v != fa[u] && v != son[u])
//                 dfs2(v, v);
//     }
//     inline void init()
//     {
//         memset(bit.t, 0, sizeof bit.t), cnt = 0;
//         memset(d, 0, sizeof d), memset(fa, 0, sizeof fa), memset(si, 0, sizeof si);
//         memset(son, 0, sizeof son), memset(dfn, 0, sizeof dfn), memset(top, 0, sizeof top);
//         dfs(1, 0), dfs2(1, 1);
//     }
//     inline void add(int u, int v, int w)
//     {
//         while (top[u] != top[v])
//         {
//             if (d[top[u]] < d[top[v]])
//                 swap(u, v);
//             bit.add(dfn[top[u]], dfn[u], w), u = fa[top[u]];
//         }
//         if (d[u] > d[v])
//             swap(u, v);
//         bit.add(dfn[u], dfn[v], w);
//     }
//     inline int ask(int u) { return bit.ask(dfn[u]); }
// } path;
// void get_root(int u, int fa, int &root, int &mxrt)
// {
//     si[u] = 1;
//     int mx = 0;
//     for (int v : g[u])
//         if (v != fa)
//         {
//             get_root(v, u, root, mxrt);
//             si[u] += si[v], mx = max(mx, si[v]);
//         }
//     if ((mx = max(mx, num - si[u])) < mxrt)
//         root = u, mxrt = mx;
// }
// priority_queue<pair<int, int>> ver[N]; // first:array_a   second:node
// void find(int u, int fa, int cnt)
// {
//     if (g[u].size() == 1 && a[u] > 0)
//         ver[cnt].push({a[u], u});
//     for (int v : g[u])
//         if (!vis[v] && v != fa)
//             find(v, u, cnt);
// }
// #define CHECK      \
//     if (q.empty()) \
//     {              \
//         fl = 1;    \
//         break;     \
//     }
// inline void calc(int u)
// {
//     int cnt = 0;
//     priority_queue<pair<pair<int, int>, int>> q; // first_first:array_a   first_second:node   second:son
//     for (int v : g[u])
//         if (!vis[v])
//         {
//             find(v, u, ++cnt);
//             if (!ver[cnt].empty())
//                 q.push({ver[cnt].top(), cnt});
//         }
//     while (a[u])
//     {
//         CHECK
//         auto v1 = q.top();
//         q.pop();
//         CHECK
//         auto v2 = q.top();
//         q.pop();
//         path.add(v1.first.second, v2.first.second, -1);
//         ver[v1.second].pop(), ver[v2.second].pop();
//         if (v1.first.first > 1)
//             ver[v1.second].push({v1.first.first - 1, v1.first.second});
//         if (v2.first.first > 1)
//             ver[v2.second].push({v2.first.first - 1, v2.first.second});
//         if (!ver[v1.second].empty())
//             q.push({ver[v1.second].top(), v1.second});
//         if (!ver[v2.second].empty())
//             q.push({ver[v2.second].top(), v2.second});
//         --a[u];
//     }
// }
// void solve(int u)
// {
//     calc(u), vis[u] = 1;
//     if (fl)
//         return;
//     for (int v : g[u])
//         if (!vis[v])
//         {
//             int root = 0, mxrt = 1e9;
//             num = si[v], get_root(v, u, root, mxrt);
//             solve(root);
//             if (fl)
//                 return;
//         }
// }
// inline void solve()
// {
//     path.init();
//     int root = 0, mxrt = 1e9;
//     num = n, get_root(1, 0, root, mxrt);
//     solve(root);
// }
// namespace next
// {
//     int n, a[N], si[N];
//     vector<int> g[N];
//     void get_root(int u, int fa, int &root, int &mxrt)
//     {
//         si[u] = 1;
//         int mx = 0;
//         for (int v : g[u])
//             if (v != fa)
//             {
//                 get_root(v, u, root, mxrt);
//                 si[u] += si[v], mx = max(mx, si[v]);
//             }
//         if ((mx = max(mx, n - si[u])) < mxrt)
//             root = u, mxrt = mx;
//     }
//     int dfs(int u, int fa)
//     {
//         if (g[u].size() == 1)
//             return a[u];
//         int sum = 0;
//         for (int v : g[u])
//             if (v != fa)
//             {
//                 int k = dfs(v, u);
//                 if (k == -1)
//                     return -1;
//                 sum += k;
//             }
//         if (sum < a[u] || a[u] - (sum - a[u]) < 0)
//             return -1;
//         return a[u] - (sum - a[u]);
//     }
//     inline void main()
//     {
//         n = read();
//         for (int i = 1; i <= n; ++i)
//             a[i] = read(), g[i].clear();
//         for (int i = 1; i < n; ++i)
//         {
//             int u = read(), v = read();
//             g[u].push_back(v), g[v].push_back(u);
//         }
//         int root = 0, mxrt = 1e9;
//         get_root(1, 0, root, mxrt);
//         puts(dfs(root, 0) == 0 ? "YES" : "NO");
//     }
// }
int n, a[N], si[N];
vector<int> g[N];
void get_root(int u, int fa, int &root, int &mxrt)
{
    si[u] = 1;
    int mx = 0;
    for (int v : g[u])
        if (v != fa)
        {
            get_root(v, u, root, mxrt);
            si[u] += si[v], mx = max(mx, si[v]);
        }
    if ((mx = max(mx, n - si[u])) < mxrt)
        root = u, mxrt = mx;
}
int dfs(int u, int fa)
{
    if (g[u].size() == 1)
        return a[u];
    int sum = 0;
    for (int v : g[u])
        if (v != fa)
        {
            int k = dfs(v, u);
            if (k == -1)
                return -1;
            sum += k;
        }
    if (sum < a[u] || a[u] - (sum - a[u]) < 0)
        return -1;
    return a[u] - (sum - a[u]);
}
signed main()
{
    freopen("clean5.in", "r", stdin);
    freopen("clean.out", "w", stdout);
    int T = read();
    while (T--)
    {
        n = read();
        for (int i = 1; i <= n; ++i)
            a[i] = read(), g[i].clear();
        for (int i = 1; i < n; ++i)
        {
            int u = read(), v = read();
            g[u].push_back(v), g[v].push_back(u);
        }
        int root = 0, mxrt = 1e9;
        get_root(1, 0, root, mxrt);
        puts(dfs(root, 0) == 0 ? "YES" : "NO");
        // next::main();
        // fl = 0, memset(vis, 0, sizeof vis);
        // n = read();
        // for (int i = 1; i <= n; ++i)
        //     a[i] = read(), g[i].clear();
        // for (int i = 1; i < n; ++i)
        // {
        //     int u = read(), v = read();
        //     g[u].push_back(v), g[v].push_back(u);
        // }
        // solve(), fl = 0;
        // for (int i = 1; i <= n; ++i)
        //     if (path.ask(i) != 0)
        //     {
        //         puts("NO"), fl = 1;
        //         break;
        //     }
        // if (!fl)
        //     puts("YES");
    }
    return 0;
}